package functional.functionalannotation;

/**
 * @ClassName FunctionVariants
 * @PackageName functional.functionalAnnotation
 * @projectName myThread
 * @Description 
 * @Author games
 * @Date 2025/8/26 下午1:40
 * @Version 1.0
 */

import java.util.function.*;

class Foo {
}

class Bar {
    Foo f;

    Bar(Foo f) {
        this.f = f;
    }
}

class IBaz {
    int i;

    IBaz(int i) {
        this.i = i;
    }
}

class LBaz {
    long l;

    LBaz(long l) {
        this.l = l;
    }
}

class DBaz {
    double d;

    DBaz(double d) {
        this.d = d;
    }
}

public class FunctionVariants {
    /**
     * 将Foo对象转换为Bar对象的函数
     *
     * @param f 输入的Foo对象
     * @return 新创建的Bar对象
     */
    static Function<Foo, Bar> f1 = f -> new Bar(f);

    /**
     * 将整数转换为IBaz对象的函数
     *
     * @param i 输入的整数值
     * @return 新创建的IBaz对象
     */
    static IntFunction<IBaz> f2 = i -> new IBaz(i);

    /**
     * 将长整数转换为LBaz对象的函数
     *
     * @param l 输入的长整数值
     * @return 新创建的LBaz对象
     */
    static LongFunction<LBaz> f3 = l -> new LBaz(l);

    /**
     * 将双精度浮点数转换为DBaz对象的函数
     *
     * @param d 输入的双精度浮点数值
     * @return 新创建的DBaz对象
     */
    static DoubleFunction<DBaz> f4 = d -> new DBaz(d);

    /**
     * 将IBaz对象转换为整数的函数
     *
     * @param ib 输入的IBaz对象
     * @return IBaz对象的整数属性值
     */
    static ToIntFunction<IBaz> f5 = ib -> ib.i;

    /**
     * 将LBaz对象转换为长整数的函数
     *
     * @param lb 输入的LBaz对象
     * @return LBaz对象的长整数属性值
     */
    static ToLongFunction<LBaz> f6 = lb -> lb.l;

    /**
     * 将DBaz对象转换为双精度浮点数的函数
     *
     * @param db 输入的DBaz对象
     * @return DBaz对象的双精度浮点数属性值
     */
    static ToDoubleFunction<DBaz> f7 = db -> db.d;

    /**
     * 将整数转换为长整数的函数
     *
     * @param i 输入的整数值
     * @return 转换后的长整数值
     */
    static IntToLongFunction f8 = i -> i;

    /**
     * 将整数转换为双精度浮点数的函数
     *
     * @param i 输入的整数值
     * @return 转换后的双精度浮点数值
     */
    static IntToDoubleFunction f9 = i -> i;

    /**
     * 将长整数转换为整数的函数
     *
     * @param l 输入的长整数值
     * @return 转换后的整数值
     */
    static LongToIntFunction f10 = l -> (int) l;

    /**
     * 将长整数转换为双精度浮点数的函数
     *
     * @param l 输入的长整数值
     * @return 转换后的双精度浮点数值
     */
    static LongToDoubleFunction f11 = l -> l;

    /**
     * 将双精度浮点数转换为整数的函数
     *
     * @param d 输入的双精度浮点数值
     * @return 转换后的整数值
     */
    static DoubleToIntFunction f12 = d -> (int) d;

    /**
     * 将双精度浮点数转换为长整数的函数
     *
     * @param d 输入的双精度浮点数值
     * @return 转换后的长整数值
     */
    static DoubleToLongFunction f13 = d -> (long) d;


    public static void main(String[] args) {
        Bar b = f1.apply(new Foo());
        IBaz ib = f2.apply(11);
        LBaz lb = f3.apply(11);
        DBaz db = f4.apply(11);
        int i = f5.applyAsInt(ib);
        long l = f6.applyAsLong(lb);
        double d = f7.applyAsDouble(db);
        l = f8.applyAsLong(12);
        d = f9.applyAsDouble(12);
        i = f10.applyAsInt(12);
        d = f11.applyAsDouble(12);
        i = f12.applyAsInt(13.0);
        l = f13.applyAsLong(13.0);
    }
}
